package FanXingT;

/**
 * @author Ajie
 * @date 2019-11-27
 * @function
 * @see extendInstanceOf
 */
// 泛型类：把泛型定义在类上
public class ObjectTool<T> {
    private T obj;
    public T getObj() {
        return obj;
    }
    public void setObj(T obj) {
        this.obj = obj;
    }
}

//  泛型类的测试
 class ObjectToolDemo {
    public static void main(String[] args) {
        ObjectTool<String> ot = new ObjectTool<String>();
        ot.setObj("demo1");
        String s = ot.getObj();
        System.out.println(s);

        ObjectTool<Integer> ot2 = new ObjectTool<Integer>();
        ot2.setObj(2018);
        Integer i = ot2.getObj();
        System.out.println(i);
    }
}


// 泛型方法
class ObjectPrint {
    public <T> void show(T t) {
        System.out.println(t);
    }
}
class ObjectToolDemoMethod {
    public static void main(String[] args) {
        ObjectPrint op = new ObjectPrint();
        op.show("demo2");
        op.show(2222);
        op.show(true);
    }
}

/* * 泛型接口：把泛型定义在接口上 */
interface Inter<T> {
    public abstract void show(T t);
}
//实现类在实现接口的时候，我们会遇到两种情况
//第一种情况：已经知道是什么类型的了
class InterImpl implements Inter<String> {
    @Override
    public void show(String t) {
        System.out.println(t);
    }
}
//第二种情况：还不知道是什么类型的
class InterImplTwo<T> implements Inter<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}
class InterDemo {
    public static void main(String[] args) {
        // 第一种情况的测试
        Inter<String> i = new InterImpl();
        i.show("hello");
        // 第二种情况的测试
        Inter<String> i2 = new InterImplTwo<>();
        i2.show("hello");
        Inter<Integer> ii = new InterImplTwo<>();
        ii.show(100);
    }
}